{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Vanilla RNN for Digit Classification\n",
    "In this tutorial we will implement a simple Recurrent Neural Network in TensorFlow for classifying MNIST digits.\n",
    "\n",
    "<img src=\"files/files/01.png\">\n",
    "\n",
    "\n",
    "*Fig1. Sample RNN structure (Left) and its unfolded representation (Right)*\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 0. Import the required libraries:\n",
    "We will start with importing the required libraries to our Python environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# imports\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from tensorflow.contrib import rnn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Load the MNIST data\n",
    "\n",
    "For this tutorial we use the MNIST dataset. MNIST is a dataset of handwritten digits. If you are into machine learning, you might have heard of this dataset by now. MNIST is kind of benchmark of datasets for deep learning. One other reason that we use the MNIST is that it is easily accesible through Tensorflow.\n",
    "\n",
    "The dataset contains 55,000 examples for training, 5,000 examples for validation and 10,000 examples for testing. The digits have been size-normalized and centered in a fixed-size image (28x28 pixels) with values from 0 to 1. For simplicity, each image has been flattened and converted to a 1-D numpy array of 784 features (28*28).\n",
    "\n",
    "![MNIST](files/files/02.png)\n",
    "\n",
    "\n",
    "If you want to know more about the MNIST dataset you can check __Yann Lecun__'s [website](http://yann.lecun.com/exdb/mnist/).\n",
    "\n",
    "### 1.1. Data dimension\n",
    "Here, we specify the dimensions of the images which will be used in several places in the code below. Defining these variables makes it easier (compared with using hard-coded number all throughout the code) to modify them later. Ideally these would be inferred from the data that has been read, but here we just write the numbers.\n",
    "\n",
    "To classify images using a recurrent neural network, we consider every image row as a sequence of pixels. Because MNIST image shape is 28x28 pixels, we will then handle 28 sequences of 28 timesteps for every sample."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Data Dimension\n",
    "num_input = 28          # MNIST data input (image shape: 28x28)\n",
    "timesteps = 28          # Timesteps\n",
    "n_classes = 10          # Number of classes, one class per digit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2. Helper functions to load the MNIST data\n",
    "\n",
    "In this section, we'll write the function which automatically loads the MNIST data and returns it in our desired shape and format. If you wanna learn more about loading your data, you may read our __How to Load Data in TensorFlow __ tutorial which explains all the available methods to load your own data; no matter how big it is. Here, we'll simply write a function (load_data) which has two mode: train (which loads the training and validation images and their corresponding labels) and test (which loads the test images and their corresponding labels). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_data(mode='train'):\n",
    "    \"\"\"\n",
    "    Function to (download and) load the MNIST data\n",
    "    :param mode: train or test\n",
    "    :return: images and the corresponding labels\n",
    "    \"\"\"\n",
    "    from tensorflow.examples.tutorials.mnist import input_data\n",
    "    mnist = input_data.read_data_sets(\"MNIST_data/\", one_hot=True)\n",
    "    if mode == 'train':\n",
    "        x_train, y_train, x_valid, y_valid = mnist.train.images, mnist.train.labels, \\\n",
    "                                             mnist.validation.images, mnist.validation.labels\n",
    "        return x_train, y_train, x_valid, y_valid\n",
    "    elif mode == 'test':\n",
    "        x_test, y_test = mnist.test.images, mnist.test.labels\n",
    "    return x_test, y_test\n",
    "\n",
    "\n",
    "def randomize(x, y):\n",
    "    \"\"\" Randomizes the order of data samples and their corresponding labels\"\"\"\n",
    "    permutation = np.random.permutation(y.shape[0])\n",
    "    shuffled_x = x[permutation, :]\n",
    "    shuffled_y = y[permutation]\n",
    "    return shuffled_x, shuffled_y\n",
    "\n",
    "\n",
    "def get_next_batch(x, y, start, end):\n",
    "    x_batch = x[start:end]\n",
    "    y_batch = y[start:end]\n",
    "    return x_batch, y_batch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3. Load the data and display the sizes\n",
    "Now we can use the defined helper function in \"train\" mode which loads the train and validation images and their corresponding labels. We'll also display their sizes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Successfully downloaded train-images-idx3-ubyte.gz 9912422 bytes.\n",
      "Extracting MNIST_data/train-images-idx3-ubyte.gz\n",
      "Successfully downloaded train-labels-idx1-ubyte.gz 28881 bytes.\n",
      "Extracting MNIST_data/train-labels-idx1-ubyte.gz\n",
      "Successfully downloaded t10k-images-idx3-ubyte.gz 1648877 bytes.\n",
      "Extracting MNIST_data/t10k-images-idx3-ubyte.gz\n",
      "Successfully downloaded t10k-labels-idx1-ubyte.gz 4542 bytes.\n",
      "Extracting MNIST_data/t10k-labels-idx1-ubyte.gz\n",
      "Size of:\n",
      "- Training-set:\t\t55000\n",
      "- Validation-set:\t5000\n"
     ]
    }
   ],
   "source": [
    "x_train, y_train, x_valid, y_valid = load_data(mode='train')\n",
    "print(\"Size of:\")\n",
    "print(\"- Training-set:\\t\\t{}\".format(len(y_train)))\n",
    "print(\"- Validation-set:\\t{}\".format(len(y_valid)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Hyperparameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "learning_rate = 0.001 # The optimization initial learning rate\n",
    "epochs = 10           # Total number of training epochs\n",
    "batch_size = 100      # Training batch size\n",
    "display_freq = 100    # Frequency of displaying the training results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Network configuration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_hidden_units = 128  # Number of hidden units of the RNN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Create network helper functions \n",
    "### 4.1. Helper functions for creating new variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# weight and bais wrappers\n",
    "def weight_variable(shape):\n",
    "    \"\"\"\n",
    "    Create a weight variable with appropriate initialization\n",
    "    :param name: weight name\n",
    "    :param shape: weight shape\n",
    "    :return: initialized weight variable\n",
    "    \"\"\"\n",
    "    initer = tf.truncated_normal_initializer(stddev=0.01)\n",
    "    return tf.get_variable('W',\n",
    "                           dtype=tf.float32,\n",
    "                           shape=shape,\n",
    "                           initializer=initer)\n",
    "\n",
    "\n",
    "def bias_variable(shape):\n",
    "    \"\"\"\n",
    "    Create a bias variable with appropriate initialization\n",
    "    :param name: bias variable name\n",
    "    :param shape: bias variable shape\n",
    "    :return: initialized bias variable\n",
    "    \"\"\"\n",
    "    initial = tf.constant(0., shape=shape, dtype=tf.float32)\n",
    "    return tf.get_variable('b',\n",
    "                           dtype=tf.float32,\n",
    "                           initializer=initial)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2. Helper-function for creating a RNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def RNN(x, weights, biases, timesteps, num_hidden):\n",
    "\n",
    "    # Prepare data shape to match `rnn` function requirements\n",
    "    # Current data input shape: (batch_size, timesteps, n_input)\n",
    "    # Required shape: 'timesteps' tensors list of shape (batch_size, n_input)\n",
    "\n",
    "    # Unstack to get a list of 'timesteps' tensors of shape (batch_size, n_input)\n",
    "    x = tf.unstack(x, timesteps, 1)\n",
    "\n",
    "    # Define a rnn cell with tensorflow\n",
    "    rnn_cell = rnn.BasicRNNCell(num_hidden)\n",
    "\n",
    "    # Get lstm cell output\n",
    "    # If no initial_state is provided, dtype must be specified\n",
    "    # If no initial cell state is provided, they will be initialized to zero\n",
    "    states_series, current_state = rnn.static_rnn(rnn_cell, x, dtype=tf.float32)\n",
    "\n",
    "    # Linear activation, using rnn inner loop last output\n",
    "    return tf.matmul(current_state, weights) + biases"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Create the network graph\n",
    "### 5.1. Placeholders for the inputs (x) and corresponding labels (y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Placeholders for inputs (x) and outputs(y)\n",
    "x = tf.placeholder(tf.float32, shape=[None, timesteps, num_input], name='X')\n",
    "y = tf.placeholder(tf.float32, shape=[None, n_classes], name='Y')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.2. Define the network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create weight matrix initialized randomely from N~(0, 0.01)\n",
    "W = weight_variable(shape=[num_hidden_units, n_classes])\n",
    "\n",
    "# create bias vector initialized as zero\n",
    "b = bias_variable(shape=[n_classes])\n",
    "\n",
    "output_logits = RNN(x, W, b, timesteps, num_hidden_units)\n",
    "y_pred = tf.nn.softmax(output_logits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.3. Define the loss function, optimizer, accuracy, and predicted class\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Model predictions\n",
    "cls_prediction = tf.argmax(output_logits, axis=1, name='predictions')\n",
    "\n",
    "# Define the loss function, optimizer, and accuracy\n",
    "loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=output_logits), name='loss')\n",
    "optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate, name='Adam-op').minimize(loss)\n",
    "correct_prediction = tf.equal(tf.argmax(output_logits, 1), tf.argmax(y, 1), name='correct_pred')\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32), name='accuracy')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.4. Initialize all variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating the op for initializing all variables\n",
    "init = tf.global_variables_initializer()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training epoch: 1\n",
      "iter   0:\t Loss=2.28,\tTraining Accuracy=17.0%\n",
      "iter 100:\t Loss=0.92,\tTraining Accuracy=74.0%\n",
      "iter 200:\t Loss=0.71,\tTraining Accuracy=77.0%\n",
      "iter 300:\t Loss=0.67,\tTraining Accuracy=77.0%\n",
      "iter 400:\t Loss=0.20,\tTraining Accuracy=94.0%\n",
      "iter 500:\t Loss=0.46,\tTraining Accuracy=91.0%\n",
      "---------------------------------------------------------\n",
      "Epoch: 1, validation loss: 0.33, validation accuracy: 92.1%\n",
      "---------------------------------------------------------\n",
      "Training epoch: 2\n",
      "iter   0:\t Loss=0.15,\tTraining Accuracy=96.0%\n",
      "iter 100:\t Loss=0.34,\tTraining Accuracy=89.0%\n",
      "iter 200:\t Loss=0.33,\tTraining Accuracy=93.0%\n",
      "iter 300:\t Loss=0.37,\tTraining Accuracy=89.0%\n",
      "iter 400:\t Loss=0.32,\tTraining Accuracy=91.0%\n",
      "iter 500:\t Loss=0.28,\tTraining Accuracy=93.0%\n",
      "---------------------------------------------------------\n",
      "Epoch: 2, validation loss: 0.24, validation accuracy: 93.4%\n",
      "---------------------------------------------------------\n",
      "Training epoch: 3\n",
      "iter   0:\t Loss=0.14,\tTraining Accuracy=97.0%\n",
      "iter 100:\t Loss=0.18,\tTraining Accuracy=94.0%\n",
      "iter 200:\t Loss=0.24,\tTraining Accuracy=92.0%\n",
      "iter 300:\t Loss=0.12,\tTraining Accuracy=99.0%\n",
      "iter 400:\t Loss=0.20,\tTraining Accuracy=93.0%\n",
      "iter 500:\t Loss=0.12,\tTraining Accuracy=96.0%\n",
      "---------------------------------------------------------\n",
      "Epoch: 3, validation loss: 0.19, validation accuracy: 95.6%\n",
      "---------------------------------------------------------\n",
      "Training epoch: 4\n",
      "iter   0:\t Loss=0.15,\tTraining Accuracy=97.0%\n",
      "iter 100:\t Loss=0.18,\tTraining Accuracy=93.0%\n",
      "iter 200:\t Loss=0.21,\tTraining Accuracy=93.0%\n",
      "iter 300:\t Loss=0.11,\tTraining Accuracy=96.0%\n",
      "iter 400:\t Loss=0.10,\tTraining Accuracy=97.0%\n",
      "iter 500:\t Loss=0.27,\tTraining Accuracy=92.0%\n",
      "---------------------------------------------------------\n",
      "Epoch: 4, validation loss: 0.19, validation accuracy: 95.0%\n",
      "---------------------------------------------------------\n",
      "Training epoch: 5\n",
      "iter   0:\t Loss=0.11,\tTraining Accuracy=97.0%\n",
      "iter 100:\t Loss=0.08,\tTraining Accuracy=98.0%\n",
      "iter 200:\t Loss=0.07,\tTraining Accuracy=97.0%\n",
      "iter 300:\t Loss=0.15,\tTraining Accuracy=97.0%\n",
      "iter 400:\t Loss=0.17,\tTraining Accuracy=95.0%\n",
      "iter 500:\t Loss=0.06,\tTraining Accuracy=100.0%\n",
      "---------------------------------------------------------\n",
      "Epoch: 5, validation loss: 0.16, validation accuracy: 95.7%\n",
      "---------------------------------------------------------\n",
      "Training epoch: 6\n",
      "iter   0:\t Loss=0.12,\tTraining Accuracy=97.0%\n",
      "iter 100:\t Loss=0.15,\tTraining Accuracy=93.0%\n",
      "iter 200:\t Loss=0.06,\tTraining Accuracy=98.0%\n",
      "iter 300:\t Loss=0.07,\tTraining Accuracy=99.0%\n",
      "iter 400:\t Loss=0.11,\tTraining Accuracy=99.0%\n",
      "iter 500:\t Loss=0.05,\tTraining Accuracy=100.0%\n",
      "---------------------------------------------------------\n",
      "Epoch: 6, validation loss: 0.13, validation accuracy: 96.1%\n",
      "---------------------------------------------------------\n",
      "Training epoch: 7\n",
      "iter   0:\t Loss=0.08,\tTraining Accuracy=97.0%\n",
      "iter 100:\t Loss=0.11,\tTraining Accuracy=95.0%\n",
      "iter 200:\t Loss=0.16,\tTraining Accuracy=94.0%\n",
      "iter 300:\t Loss=0.17,\tTraining Accuracy=95.0%\n",
      "iter 400:\t Loss=0.04,\tTraining Accuracy=99.0%\n",
      "iter 500:\t Loss=0.04,\tTraining Accuracy=100.0%\n",
      "---------------------------------------------------------\n",
      "Epoch: 7, validation loss: 0.12, validation accuracy: 96.6%\n",
      "---------------------------------------------------------\n",
      "Training epoch: 8\n",
      "iter   0:\t Loss=0.10,\tTraining Accuracy=98.0%\n",
      "iter 100:\t Loss=0.14,\tTraining Accuracy=98.0%\n",
      "iter 200:\t Loss=0.03,\tTraining Accuracy=100.0%\n",
      "iter 300:\t Loss=0.06,\tTraining Accuracy=98.0%\n",
      "iter 400:\t Loss=0.10,\tTraining Accuracy=98.0%\n",
      "iter 500:\t Loss=0.11,\tTraining Accuracy=96.0%\n",
      "---------------------------------------------------------\n",
      "Epoch: 8, validation loss: 0.12, validation accuracy: 96.3%\n",
      "---------------------------------------------------------\n",
      "Training epoch: 9\n",
      "iter   0:\t Loss=0.06,\tTraining Accuracy=98.0%\n",
      "iter 100:\t Loss=0.08,\tTraining Accuracy=97.0%\n",
      "iter 200:\t Loss=0.05,\tTraining Accuracy=99.0%\n",
      "iter 300:\t Loss=0.21,\tTraining Accuracy=96.0%\n",
      "iter 400:\t Loss=0.21,\tTraining Accuracy=96.0%\n",
      "iter 500:\t Loss=0.08,\tTraining Accuracy=97.0%\n",
      "---------------------------------------------------------\n",
      "Epoch: 9, validation loss: 0.14, validation accuracy: 95.7%\n",
      "---------------------------------------------------------\n",
      "Training epoch: 10\n",
      "iter   0:\t Loss=0.10,\tTraining Accuracy=98.0%\n",
      "iter 100:\t Loss=0.17,\tTraining Accuracy=95.0%\n",
      "iter 200:\t Loss=0.07,\tTraining Accuracy=98.0%\n",
      "iter 300:\t Loss=0.15,\tTraining Accuracy=95.0%\n",
      "iter 400:\t Loss=0.10,\tTraining Accuracy=99.0%\n",
      "iter 500:\t Loss=0.04,\tTraining Accuracy=99.0%\n",
      "---------------------------------------------------------\n",
      "Epoch: 10, validation loss: 0.14, validation accuracy: 95.4%\n",
      "---------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "sess = tf.InteractiveSession()\n",
    "sess.run(init)\n",
    "global_step = 0\n",
    "# Number of training iterations in each epoch\n",
    "num_tr_iter = int(len(y_train) / batch_size)\n",
    "for epoch in range(epochs):\n",
    "    print('Training epoch: {}'.format(epoch + 1))\n",
    "    x_train, y_train = randomize(x_train, y_train)\n",
    "    for iteration in range(num_tr_iter):\n",
    "        global_step += 1\n",
    "        start = iteration * batch_size\n",
    "        end = (iteration + 1) * batch_size\n",
    "        x_batch, y_batch = get_next_batch(x_train, y_train, start, end)\n",
    "        x_batch = x_batch.reshape((batch_size, timesteps, num_input))\n",
    "        # Run optimization op (backprop)\n",
    "        feed_dict_batch = {x: x_batch, y: y_batch}\n",
    "        sess.run(optimizer, feed_dict=feed_dict_batch)\n",
    "\n",
    "        if iteration % display_freq == 0:\n",
    "            # Calculate and display the batch loss and accuracy\n",
    "            loss_batch, acc_batch = sess.run([loss, accuracy],\n",
    "                                             feed_dict=feed_dict_batch)\n",
    "\n",
    "            print(\"iter {0:3d}:\\t Loss={1:.2f},\\tTraining Accuracy={2:.01%}\".\n",
    "                  format(iteration, loss_batch, acc_batch))\n",
    "\n",
    "    # Run validation after every epoch\n",
    "\n",
    "    feed_dict_valid = {x: x_valid[:1000].reshape((-1, timesteps, num_input)), y: y_valid[:1000]}\n",
    "    loss_valid, acc_valid = sess.run([loss, accuracy], feed_dict=feed_dict_valid)\n",
    "    print('---------------------------------------------------------')\n",
    "    print(\"Epoch: {0}, validation loss: {1:.2f}, validation accuracy: {2:.01%}\".\n",
    "          format(epoch + 1, loss_valid, acc_valid))\n",
    "    print('---------------------------------------------------------')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. Test\n",
    "### 7.1. Helper functions for plotting the results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_images(images, cls_true, cls_pred=None, title=None):\n",
    "    \"\"\"\n",
    "    Create figure with 3x3 sub-plots.\n",
    "    :param images: array of images to be plotted, (9, img_h*img_w)\n",
    "    :param cls_true: corresponding true labels (9,)\n",
    "    :param cls_pred: corresponding true labels (9,)\n",
    "    \"\"\"\n",
    "    fig, axes = plt.subplots(3, 3, figsize=(9, 9))\n",
    "    fig.subplots_adjust(hspace=0.3, wspace=0.3)\n",
    "    for i, ax in enumerate(axes.flat):\n",
    "        # Plot image.\n",
    "        ax.imshow(np.squeeze(images[i]).reshape(28, 28), cmap='binary')\n",
    "\n",
    "        # Show true and predicted classes.\n",
    "        if cls_pred is None:\n",
    "            ax_title = \"True: {0}\".format(cls_true[i])\n",
    "        else:\n",
    "            ax_title = \"True: {0}, Pred: {1}\".format(cls_true[i], cls_pred[i])\n",
    "\n",
    "        ax.set_title(ax_title)\n",
    "\n",
    "        # Remove ticks from the plot.\n",
    "        ax.set_xticks([])\n",
    "        ax.set_yticks([])\n",
    "\n",
    "    if title:\n",
    "        plt.suptitle(title, size=20)\n",
    "    plt.show(block=False)\n",
    "    \n",
    "def plot_example_errors(images, cls_true, cls_pred, title=None):\n",
    "    \"\"\"\n",
    "    Function for plotting examples of images that have been mis-classified\n",
    "    :param images: array of all images, (#imgs, img_h*img_w)\n",
    "    :param cls_true: corresponding true labels, (#imgs,)\n",
    "    :param cls_pred: corresponding predicted labels, (#imgs,)\n",
    "    \"\"\"\n",
    "    # Negate the boolean array.\n",
    "    incorrect = np.logical_not(np.equal(cls_pred, cls_true))\n",
    "\n",
    "    # Get the images from the test-set that have been\n",
    "    # incorrectly classified.\n",
    "    incorrect_images = images[incorrect]\n",
    "\n",
    "    # Get the true and predicted classes for those images.\n",
    "    cls_pred = cls_pred[incorrect]\n",
    "    cls_true = cls_true[incorrect]\n",
    "\n",
    "    # Plot the first 9 images.\n",
    "    plot_images(images=incorrect_images[0:9],\n",
    "                cls_true=cls_true[0:9],\n",
    "                cls_pred=cls_pred[0:9],\n",
    "                title=title)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.2. Run the test and plot some results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting MNIST_data/train-images-idx3-ubyte.gz\n",
      "Extracting MNIST_data/train-labels-idx1-ubyte.gz\n",
      "Extracting MNIST_data/t10k-images-idx3-ubyte.gz\n",
      "Extracting MNIST_data/t10k-labels-idx1-ubyte.gz\n",
      "---------------------------------------------------------\n",
      "Test loss: 0.16, test accuracy: 95.1%\n",
      "---------------------------------------------------------\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAggAAAI7CAYAAACJEmNgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 648x648 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAggAAAI7CAYAAACJEmNgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAMK/TirVXYVCe5kAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 648x648 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Test the network (only on 1000 samples) after training\n",
    "# Accuracy\n",
    "x_test, y_test = load_data(mode='test')\n",
    "feed_dict_test = {x: x_test[:1000].reshape((-1, timesteps, num_input)), y: y_test[:1000]}\n",
    "loss_test, acc_test = sess.run([loss, accuracy], feed_dict=feed_dict_test)\n",
    "print('---------------------------------------------------------')\n",
    "print(\"Test loss: {0:.2f}, test accuracy: {1:.01%}\".format(loss_test, acc_test))\n",
    "print('---------------------------------------------------------')\n",
    "\n",
    "\n",
    "# Plot some of the correct and misclassified examples\n",
    "cls_pred = sess.run(cls_prediction, feed_dict=feed_dict_test)\n",
    "cls_true = np.argmax(y_test, axis=1)\n",
    "plot_images(x_test, cls_true, cls_pred, title='Correct Examples')\n",
    "plot_example_errors(x_test[:1000], cls_true[:1000], cls_pred, title='Misclassified Examples')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After we are finished the testing, we will close the session to free the memory."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Thanks for reading! If you have any question or doubt, feel free to leave a comment in our [website](http://easy-tensorflow.com/)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
